333 research outputs found
A teaching and support tool for building formal models of graphical user-interfaces
In this paper we propose the design of a tool that will allow the construction of a formal, textual description of a software system even if it has a graphical user-interface as a component. An important aspect of this design is that it can be used for two purposes-the teaching of first-order logic and the formal specification of graphical user-interfaces. The design has been suggested by considering a system that has already been very successful for teaching first-order logic, namely Tarski's World
Considering reachability when comparing data refinements
Adding considerations about reachability to the Logics of Specification Languages [1] chapter [2]
Specifying collaborative software: a proposal
The aim of this paper is to illustrate how formal specifications for collaborative interactive systems might be written. It presents a new modelling paradigm for certain systems. It also shows how formal software engineering approaches can be useful. Specifically we choose to specify a simple collaborative editor. This example serves two purposes: it shows how clear and simple a formal specification can be and it provides a basis for making observations about the requirements for a specification language where the target is CSCW systems. The specification of the system has three parts: the semantics of the system; the syntax of the system; the semantics of the collaborative aspects of the system
Refinement for Probabilistic Systems with Nondeterminism
Before we combine actions and probabilities two very obvious questions should
be asked. Firstly, what does "the probability of an action" mean? Secondly, how
does probability interact with nondeterminism? Neither question has a single
universally agreed upon answer but by considering these questions at the outset
we build a novel and hopefully intuitive probabilistic event-based formalism.
In previous work we have characterised refinement via the notion of testing.
Basically, if one system passes all the tests that another system passes (and
maybe more) we say the first system is a refinement of the second. This is, in
our view, an important way of characterising refinement, via the question "what
sort of refinement should I be using?"
We use testing in this paper as the basis for our refinement. We develop
tests for probabilistic systems by analogy with the tests developed for
non-probabilistic systems. We make sure that our probabilistic tests, when
performed on non-probabilistic automata, give us refinement relations which
agree with for those non-probabilistic automata. We formalise this property as
a vertical refinement.Comment: In Proceedings Refine 2011, arXiv:1106.348
State-based and process-based value passing
State-based and process-based formalisms each come with their own distinct set of assumptions and properties. To combine them in a useful way it is important to be sure of these assumptions in order that the formalisms are combined in ways which have, or which allow, the intended combined properties. Consequently we cannot necessarily expect to take on state-based formalism and one process-based formalism and combine them and get something sensible, especially since the act of combining can have subtle consequences.
Here we concentrate on value-passing, how it is treated in each formalism, and how the formalisms can be combined so as to preserve certain properties. Specifically, the aim is to take from the many process-based formalisms definitions that will best fit with our chosen stat-based formalism, namely Z, so that the fit is simple, has no unintended consequences and is as elegant as possible
Constructive Mathematics in Theory and Programming Practice
The first part of the paper introduces the varieties of modern constructive mathematics, concentrating on Bishopās constructive mathematics(BISH). It gives a sketch of both Myhillās axiomatic system for BISH and a constructive axiomatic development of the real line R. The second part of the paper focuses on the relation between constructive mathematics and programming, with emphasis on Martin-Lofās theory of types as a formal system for BISH
Experiences using Z animation tools.
In this paper we describe our experience of using three different animation systems. We searched for and decided to use these tools in the context of a project which involved developing formal versions (in Z) of informal requirements documents, and then showing the formal versions to people in industry who were not Z users (or users of any formal techniques). So, an animator seemed a good way of showing the behaviour of a system described formally without the audience having to learn Z. A requirement, however, that the tools used have to satisfy is that they correctly animated Z (whatever that may mean) and they behave adequately in terms of speed and presentation. We have to report that none of the tools we looked at satisfy these requirements--though to be fair all of them are still under development
Constructing programs or processes
We define interacting sequential programs, motivated originally by constructivist considerations. We use them to investigate notions of implementation and determinism. Process algebras do not define what can be implemented and what cannot. As we demonstrate it is problematic to do so on the set of all processes. Guided by constructivist notions we have constructed interacting sequential programs which we claim can be readily implemented and are a subset of processes
Āµ-Charts and Z: Examples and extensions
Ī¼-Charts are a way of specifying reactive systems, i.e. systems which are in some environment to which they have to react, based on the well-established formalism Statecharts. This paper gives (very abbreviated) examples of translating Ī¼-charts to Z, which is itself a well-established language for specifying computational systems with tried and tested methods and support tools which guide its effective use in systems development. We undertake this translation in order that investigation of the modelled system can be performed before expensive and lengthy implementation is considered. We also present an extension of the Ī¼-charts and the related Z to deal with a simple command language, local variables and integer-valued signals
Atomic components
There has been much interest in components that combine the best of state-based and event-based approaches. The interface of a component can be thought of as its specification and substituting components with the same interface cannot be observed by any user of the components. Here we will define the semantics of atomic components where both states and event can be part of the interface. The resulting semantics is very similar to that of (event only) processes. But it has two main novelties: one, it does not need recursion or unique fixed points to model nontermination; and two, the behaviour of divergence is modelled by abstraction, i.e. the construction of the observational semantics
- ā¦